Usenet 1993 July/InfoMagic USENET CD-ROM July 1993.ISO/sources/unix/volume8/jove/part11

Internet Message Format | 1987-02-03 | 34.7 KB

Subject:  v08i030:  The JOVE text editor, Part11/13
Newsgroups: mod.sources
Approved: mirror!rs

Submitted by: seismo!rochester!jpayne (Jonathan Payne)
Mod.sources: Volume 8, Issue 30
Archive-name: jove/Part11

#! /bin/sh
# This is a shell archive.  Remove anything before this line,
# then unpack it by saving it in a file and typing "sh file".
# If all goes well, you will see the message "End of archive 11 (of 13)."
# Contents:  doc/jove.4
PATH=/bin:/usr/bin:/usr/ucb; export PATH
echo shar: extracting "'doc/jove.4'" '(33524 characters)'
if test -f 'doc/jove.4' ; then
  echo shar: will not over-write existing file "'doc/jove.4'"
else
sed 's/^X//' >doc/jove.4 <<'@//E*O*F doc/jove.4//'
X.bp
X.NH 1
XAlphabetical List of Commands and Variables
X.dc "prefix-1" "Escape"
XThis reads the next character and runs a command based on the character
Xtyped.  If you wait for more than a second or so before typing the next
Xcharacter, the message "ESC" will be printed on the message line to
Xremind you that \s-2JOVE\s0 is waiting for another character.
X.dc "prefix-2" "C-X"
XThis reads the next character and runs a command based on the character
Xtyped.  If you wait for more than a second or so before typing another
Xcharacter, the message "C-X" will be printed on the message line to
Xremind you that \s-2JOVE\s0 is waiting for another character.
X.dc "prefix-3" "Not Bound"
XThis reads the next character and runs a command based on the character
Xtyped.  If you wait for more than a second or so before typing the next
Xcharacter, the character that invoked Prefix-3 will be printed on the
Xmessage line to remind you that \s-2JOVE\s0 is waiting for another one.
X.dc "allow-^S-and-^Q" "(variable)"
XThis variable, when set, tells \s-2JOVE\s0 that your terminal does not need
Xto use the characters C-S and C-Q for flow control, and that it is
Xokay to bind things to them.  This variable should be set depending
Xupon what kind of terminal you have.
X.dc "allow-bad-filenames" "(variable)"
XIf set, this variable permits filenames to contain "bad" characters
Xsuch as those from the set *&%!"`[]{}.  These files are harder to deal
Xwith, because the characters mean something to the shell.  The default
Xvalue is "off".
X.dc "append-region" "Not Bound"
XThis appends the region to a specified file.  If the file does not
Xalready exist it is created.
X.dc "apropos" "Not Bound"
XThis types out all the commands, variables and macros with the specific
Xkeyword in their names.  For each command and macro that contains the
Xstring, the key sequence that can be used to execute the command or macro is
Xprinted; with variables, the current value is printed.  So, to find all the
Xcommands that are related to windows, you type
X.DS
XESC X apropos window<Return>
X.DE
X.dc "auto-case-abbrev" "(variable)"
XWhen this variable is on (the default), word abbreviations are adjusted for
Xcase automatically.  For example, if "jove" were the abbreviation for
X"jonathan's own version of emacs", then typing "jove" would give you
X"jonathan's own version of emacs", typing "Jove" would give you "Jonathan's
Xown version of emacs", and typing "JOVE" would give you "Jonathan's Own
XVersion of Emacs".  When this variable is "off", upper and lower case are
Xdistinguished when looking for the abbreviation, i.e., in the example above,
X"JOVE" and "Jove" would not be expanded unless they were defined separately.
X.dc "auto-execute-command" "Not Bound"
XThis tells \s-2JOVE\s0 to execute a command automatically when a file whose
Xname matches a specified pattern is visited.  The first argument is the
Xcommand you want executed and the second is a regular expression
Xpattern that specifies the files that apply.  For example, if you want
Xto be in show-match-mode when you edit C source files (that is, files
Xthat end with ".c" or ".h") you can type
X.ID
XESC X auto-execute-command show-match-mode .*\.[ch]$
X.DE
X.dc "auto-execute-macro" "Not Bound"
XThis is like
X.IQ auto-execute-command
Xexcept you use it to execute macros
Xautomatically instead of built-in commands.
X.dc "auto-fill-mode" "Not Bound"
XThis turns on Auto Fill mode (or off if it's currently on) in the
Xselected buffer.  When \s-2JOVE\s0 is in Auto Fill mode it automatically
Xbreaks lines for you when you reach the right margin so you don't have
Xto remember to hit Return.  \s-2JOVE\s0 uses 78 as the right margin but you
Xcan change that by setting the variable
X.IQ right-margin
Xto another
Xvalue.  See the
X.IQ set
Xcommand to learn how to do this.
X.dc "auto-indent-mode" "Not Bound"
XThis turns on Auto Indent mode (or off if it's currently on) in the
Xselected buffer.  When \s-2JOVE\s0 is in Auto Indent mode, Return indents the
Xnew line to the same position as the line you were just on.  This is
Xuseful for lining up C code (or any other language (but what else is
Xthere besides C?)).  This is out of date because of the new command
Xcalled
X.IQ newline-and-indent
Xbut it remains because of several
X"requests" on the part of, uh, enthusiastic and excitable users, that
Xit be left as it is.
X.dc "backward-character" "C-B"
XThis moves point backward over a single character.  If point is at the
Xbeginning of the line it moves to the end of the previous line.
X.dc "backward-paragraph" "ESC ["
XThis moves point backward to the beginning of the current or previous
Xparagraph.  Paragraphs are bounded by lines that begin with a Period or
XTab, or by blank lines; a change in indentation may also signal a break
Xbetween paragraphs, except that \s-2JOVE\s0 allows the first line of a paragraph
Xto be indented differently from the other lines.
X.dc "backward-s-expression" "ESC C-B"
XThis moves point backward over a s-expression.  It is just like
X.IQ forward-s-expression
Xwith a negative argument.
X.dc "backward-sentence" "ESC A"
XThis moves point backward to the beginning of the current or previous
Xsentence.  \s-2JOVE\s0 considers the end of a sentence to be the characters
X".", "!" or "?" followed by a Return or by one or more spaces.
X.dc "backward-word" "ESC B"
XThis moves point backward to the beginning of the current or previous
Xword.
X.dc "bad-filename-extensions" "(variable)"
XThis contains a list of words separated by spaces which are to be
Xconsidered bad filename extensions, and so will not be counted in
Xfilename completion.  The default is ".o" so if you have jove.c and
Xjove.o in the same directory, the filename completion will not complain
Xof an ambiguity because it will ignore jove.o.
X.dc "beginning-of-file" "ESC <"
XThis moves point backward to the beginning of the buffer.  This sometimes
Xprints the "Point Pushed" message.  If the top of the buffer isn't on the
Xscreen \s-2JOVE\s0 will set the mark so you can go back to where you were
Xif you want.
X.dc "beginning-of-line" "C-A"
XThis moves point to the beginning of the current line.
X.dc "beginning-of-window" "ESC ,"
XThis moves point to the beginning of the current window.  The sequence
X"ESC ," is the same as "ESC <" (beginning of file) except without the shift
Xkey on the "<", and can thus can easily be remembered.
X.dc "bind-to-key" "Not Bound"
XThis attaches a key to an internal \s-2JOVE\s0 command so that future hits on
Xthat key invoke that command.  For example, to make "C-W" erase the
Xprevious word, you type "ESC X bind-to-key kill-previous-word C-W".
X.dc "bind-macro-to-key" "Not Bound"
XThis is like
X.IQ bind-to-key
Xexcept you use it to attach keys to
Xnamed macros.
X.dc "bind-macro-to-word-abbrev" "Not Bound"
XThis command allows you to bind a macro to a previously defined word
Xabbreviation.  Whenever you type the abbreviation, it will first be expanded
Xas an abbreviation, and then the macro will be executed.  Note that if the
Xmacro moves around, you should set the mark first (C-@) and then exchange
Xthe point and mark last (C-X C-X).
X.dc "buffer-position" "Not Bound"
XThis displays the current file name, current line number, total number
Xof lines, percentage of the way through the file, and the position of
Xthe cursor in the current line.
X.dc "c-mode" "Not Bound"
XThis turns on C mode in the currently selected buffer.  This is one of
Xcurrently four possible major modes:  Fundamental, Text, C, Lisp.
XWhen in C or Lisp mode, Tab, "}", and ")" behave a little differently
Xfrom usual: They are indented to the "right" place for C (or Lisp)
Xprograms.  In \s-2JOVE\s0, the "right" place is simply the way the author
Xlikes it (but I've got good taste).
X.dc "case-character-capitalize" "Not Bound"
XThis capitalizes the character after point, i.e., the character undo
Xthe cursor.  If a negative argument is supplied that many characters
X.IQ before
Xpoint are upper cased.
X.dc "case-ignore-search" "(variable)"
XThis variable, when set, tells \s-2JOVE\s0 to treat upper and lower case as
Xthe same when searching.  Thus "jove" and "JOVE" would match, and
X"JoVe" would match either.  The default value of this variable is "off".
X.dc "case-region-lower" "Not Bound"
XThis changes all the upper case letters in the region to their lower
Xcase equivalent.
X.dc "case-region-upper" "Not Bound"
XThis changes all the lower case letters in the region to their upper
Xcase equivalent.
X.dc "case-word-capitalize" "ESC C"
XThis capitalizes the current word by making the current letter upper
Xcase and making the rest of the word lower case.  Point is moved to
Xthe end of the word.  If point is not positioned on a word it is first
Xmoved forward to the beginning of the next word.  If a negative
Xargument is supplied that many words
X.IQ before
Xpoint are capitalized.
XThis is useful for correcting the word just typed without having to
Xmove point to the beginning of the word yourself.
X.dc "case-word-lower" "ESC L"
XThis lower-cases the current word and leaves point at the end of it.
XIf point is in the middle of a word the rest of the word is
Xconverted.  If point is not in a word it is first moved forward to the
Xbeginning of the next word.  If a negative argument is supplied that
Xmany words
X.IQ before
Xpoint are converted to lower case.  This is useful
Xfor correcting the word just typed without having to move point to the
Xbeginning of the word yourself.
X.dc "case-word-upper" "ESC U"
XThis upper-cases the current word and leaves point at the end of it.
XIf point is in the middle of a word the rest of the word is
Xconverted.  If point is not in a word it is first moved forward to the
Xbeginning of the next word.  If a negative argument is supplied that
Xmany words
X.IQ before
Xpoint are converted to upper case.  This is useful
Xfor correcting the word just typed without having to move point to the
Xbeginning of the word yourself.
X.dc "character-to-octal-insert" "Not Bound"
XThis inserts a Back-slash followed by the ascii value of the next
Xcharacter typed.  For example, "C-G" inserts the string "\\007".
X.dc "cd" "Not Bound"
XThis changes the current directory.
X.dc "clear-and-redraw" "ESC C-L"
XThis clears the entire screen and redraws all the windows.  Use this
Xwhen \s-2JOVE\s0 gets confused about what's on the screen, or when the screen
Xgets filled with garbage characters or output from another program.
X.dc "comment-format" "(variable)"
XThis variable tells \s-2JOVE\s0 how to format your comments when you run the
Xcommand
X.IQ fill-comment.
XIts format is this:
X.ID
X<open pattern>%!<line header>%c<line trailer>%!<close pattern>
X.DE
XThe %!, %c, and %! must appear in the format; everything else is optional.
XA newline (represented by %n) may appear in the open or close patterns.  %%
Xis the representation for %.  The default comment format is for C comments.
XSee
X.IQ fill-comment
Xfor more.
X.dc "compile-it" "C-X C-E"
XThis compiles your program by running the UNIX command "make" into a buffer,
Xand automatically parsing the error messages that are created (if any).  See
Xthe
X.IQ parse-errors
Xand
X.IQ parse-special-errors
Xcommands.  To compile
Xa C program without "make", use "C-U C-X C-E" and \s-2JOVE\s0 will prompt
Xfor a command to run instead of make.  (And then the command you type will
Xbecome the default command.)  You can use this to parse the output from the
XC compiler or the "grep" or "lint" programs.
X.dc "continue-process" "Not Bound"
XThis sends SIGCONT to the current interactive process,
X.IQ if
Xthe process
Xis currently stopped.
X.dc "copy-region" "ESC W"
XThis takes all the text in the region and copies it onto the kill ring
Xbuffer.  This is just like running
X.IQ kill-region
Xfollowed by the
X.IQ yank
Xcommand.  See the
X.IQ kill-region
Xand
X.IQ yank
Xcommands.
X.dc "current-error" "Not Bound"
XThis moves to the current error in the list of parsed errors.  See the
X.IQ next-error
Xand
X.IQ previous-error
Xcommands for more detailed
Xinformation.
X.dc "date" "Not Bound"
XThis prints the date on the message line.
X.dc "define-mode-word-abbrev" "Not Bound"
XThis defines a mode-specific abbreviation.
X.dc "define-global-word-abbrev" "Not Bound"
XThis defines a global abbreviation.
X.dc "delete-blank-lines" "C-X C-O"
XThis deletes all the blank lines around point.  This is useful when you
Xpreviously opened many lines with "C-O" and now wish to delete the
Xunused ones.
X.dc "delete-buffer" "C-X K"
XThis deletes a buffer and frees up all the memory associated with it.
XBe careful!  Once a buffer has been deleted it is gone forever.  \s-2JOVE\s0
Xwill ask you to confirm if you try to delete a buffer that needs
Xsaving.  This command is useful for when \s-2JOVE\s0 runs out of space to
Xstore new buffers.
X.dc "delete-macro" "Not Bound"
XThis deletes a macro from the list of named macros.  It is an error to
Xdelete the keyboard-macro.  Once the macro is deleted it is gone forever.
XIf you are about to save macros to a file and decide you don't want to save
Xa particular one, delete it.
X.dc "delete-next-character" "C-D"
XThis deletes the character that's just after point (that is, the
Xcharacter under the cursor).  If point is at the end of a line, the
Xline separator is deleted and the next line is joined with the current
Xone.
X.dc "delete-other-windows" "C-X 1"
XThis deletes all the other windows except the current one.  This can be
Xthought of as going back into One Window mode.
X.dc "delete-previous-character" "Rubout"
XThis deletes the character that's just before point (that is, the
Xcharacter before the cursor).  If point is at the beginning of the
Xline, the line separator is deleted and that line is joined with the
Xprevious one.
X.dc "delete-white-space" "ESC \\\\"
XThis deletes all the Tabs and Spaces around point.
X.dc "delete-current-window" "C-X D"
XThis deletes the current window and moves point into one of the
Xremaining ones.  It is an error to try to delete the only remaining
Xwindow.
X.dc "describe-bindings" "Not Bound"
XThis types out a list containing each bound key and the command that gets
Xinvoked every time that key is typed.  To make a wall chart of \s-2JOVE\s0
Xcommands, set
X.IQ send-typeout-to-buffer
Xto "on" and \s-2JOVE\s0 will
Xstore the key bindings in a buffer which you can save to a file and then
Xprint.
X.dc "describe-command" "Not Bound"
XThis prints some info on a specified command.
X.dc "describe-key" "Not Bound"
XThis waits for you to type a key and then tells the name of the
Xcommand that gets invoked every time that key is hit.  Once you have
Xthe name of the command you can use the
X.IQ describe-command
Xcommand
Xto find out exactly what it does.
X.dc "describe-variable" "Not Bound"
XThis prints some info on a specified variable.
X.dc "digit" "ESC [0-9]"
XThis reads a numeric argument.  When you type "ESC" followed by a
Xnumber, "digit" keeps reading numbers until you type some other
Xcommand.  Then that command is executes with the numeric argument you
Xspecified.
X.dc "digit-1" "Not Bound"
XThis pretends you typed "ESC 1".  This is useful for terminals that
Xhave keypads that send special sequences for numbers typed on the
Xkeypad as opposed to numbers typed from the keyboard.  This can save
Xhaving type "ESC" when you want to specify an argument.
X.dc "digit-2" "Not Bound"
XThis pretends you typed "ESC 2".  This is useful for terminals that
Xhave keypads that send special sequences for numbers typed on the
Xkeypad as opposed to numbers typed from the keyboard.  This can save
Xhaving type "ESC" when you want to specify an argument.
X.dc "digit-3" "Not Bound"
XThis pretends you typed "ESC 3".  This is useful for terminals that
Xhave keypads that send special sequences for numbers typed on the
Xkeypad as opposed to numbers typed from the keyboard.  This can save
Xhaving type "ESC" when you want to specify an argument.
X.dc "digit-4" "Not Bound"
XThis pretends you typed "ESC 4".  This is useful for terminals that
Xhave keypads that send special sequences for numbers typed on the
Xkeypad as opposed to numbers typed from the keyboard.  This can save
Xhaving type "ESC" when you want to specify an argument.
X.dc "digit-5" "Not Bound"
XThis pretends you typed "ESC 5".  This is useful for terminals that
Xhave keypads that send special sequences for numbers typed on the
Xkeypad as opposed to numbers typed from the keyboard.  This can save
Xhaving type "ESC" when you want to specify an argument.
X.dc "digit-6" "Not Bound"
XThis pretends you typed "ESC 6".  This is useful for terminals that
Xhave keypads that send special sequences for numbers typed on the
Xkeypad as opposed to numbers typed from the keyboard.  This can save
Xhaving type "ESC" when you want to specify an argument.
X.dc "digit-7" "Not Bound"
XThis pretends you typed "ESC 7".  This is useful for terminals that
Xhave keypads that send special sequences for numbers typed on the
Xkeypad as opposed to numbers typed from the keyboard.  This can save
Xhaving type "ESC" when you want to specify an argument.
X.dc "digit-8" "Not Bound"
XThis pretends you typed "ESC 8".  This is useful for terminals that
Xhave keypads that send special sequences for numbers typed on the
Xkeypad as opposed to numbers typed from the keyboard.  This can save
Xhaving type "ESC" when you want to specify an argument.
X.dc "digit-9" "Not Bound"
XThis pretends you typed "ESC 9".  This is useful for terminals that
Xhave keypads that send special sequences for numbers typed on the
Xkeypad as opposed to numbers typed from the keyboard.  This can save
Xhaving type "ESC" when you want to specify an argument.
X.dc "digit-0" "Not Bound"
XThis pretends you typed "ESC 0".  This is useful for terminals that
Xhave keypads that send special sequences for numbers typed on the
Xkeypad as opposed to numbers typed from the keyboard.  This can save
Xhaving type "ESC" when you want to specify an argument.
X.dc "dirs" "Not Bound"
XThis prints out the directory stack.  See the "cd", "pushd", "popd"
Xcommands for more info.
X.dc "disable-biff" "(variable)"
XWhen this is set, \s-2JOVE\s0 disables biff when you're editing and enables it
Xagain when you get out of \s-2JOVE\s0, or when you pause to the parent shell
Xor push to a new shell. (This means arrival of new mail will not be
Ximmediately apparent but will not cause indiscriminate writing on the
Xdisplay). The default is "off".
X.dc "dstop-process" "Not Bound"
XSend the "dsusp" character to the current process.  This is the
Xcharacter that suspends a process on the next read from the
Xterminal.  Most people have it set to C-Y.  This only works if
Xyou have the interactive process feature, and if you are in a
Xbuffer bound to a process.
X.dc "edit-word-abbrevs" "Not Bound"
XThis creates a buffer with a list of each abbreviation and the phrase
Xit expands into, and enters a recursive edit to let you change the
Xabbreviations or add some more.  The format of this list is
X"abbreviation:phrase" so if you add some more you should follow that
Xformat.  It's probably simplest just to copy some already existing
Xabbreviations and edit them.  When you are done you type "C-X C-C" to
Xexit the recursive edit.
X.dc "end-of-file" "ESC >"
XThis moves point forward to the end of the buffer.  This sometimes
Xprints the "Point Pushed" message.  If the end of the buffer isn't on
Xthe screen \s-2JOVE\s0 will set the mark so you can go back to where you were
Xif you want.
X.dc "end-of-line" "C-E"
XThis moves point to the end of the current line.  If the line is too
Xlong to fit on the screen \s-2JOVE\s0 will scroll the line to the left to
Xmake the end of the line visible.  The line will slide back to its
Xnormal position when you move backward past the leftmost visible character
Xor when you move off the line altogether.
X.dc "end-of-window" "ESC ."
XThis moves point to the last character in the window.
X.dc "eof-process" "Not Bound"
XSends EOF to the current interactive process.  This only works on
Xversions of \s-2JOVE\s0 which run under 4.2-3 BSD VAX UNIX.  You can't send
XEOF to processes on the 2.9 BSD PDP-11 UNIX.
X.dc "erase-buffer" "Not Bound"
XThis erases the contents of the specified buffer.  This is like
X.IQ delete-buffer
Xexcept it only erases the contents of the buffer, not
Xthe buffer itself.  If you try to erase a buffer that needs saving you
Xwill be asked to confirm it.
X.dc "error-window-size" "(variable)"
XThis is the percentage of the screen to use for the error-window on the
Xscreen.  When you execute
X.IQ compile-it,
X.IQ error-window-size
Xpercent of the screen will go to the error window.  If the window already
Xexists and is a different size, it is made to be this size.  The default
Xvalue is 20%.
X.dc "exchange-point-and-mark" "C-X C-X"
XThis moves point to mark and makes mark the old point.  This is for
Xquickly moving from one end of the region to another.
X.dc "execute-named-command" "ESC X"
XThis is the way to execute a command that isn't bound to any key.
XWhen you are prompted with ": " you can type the name of the
Xcommand.  You don't have to type the entire name.  Once the command
Xis unambiguous you can type Space and \s-2JOVE\s0 will fill in the rest for
Xyou.
XIf you are not sure of the name of the command, type "?" and \s-2JOVE\s0
Xwill print a list of all the commands that you could possibly match
Xgiven what you've already typed.  If you don't have any idea what the
Xcommand's name is but you know it has something to do with windows
X(for example), you can do "ESC X apropos window" and \s-2JOVE\s0 will print a
Xlist of all the commands that are related to windows.
XIf you find yourself constantly executing the same commands this way
Xyou probably want to bind them to keys so that you can execute them
Xmore quickly.  See the
X.IQ bind-to-key
Xcommand.
X.dc "execute-keyboard-macro" "C-X E"
XThis executes the keyboard macro.  If you supply a numeric argument the
Xmacro is executed that many times.
X.dc "execute-macro" "Not Bound"
XThis executes a specified macro.  If you supply a numeric argument the
Xmacro is executed that many times.
X.dc "exit-jove" "C-X C-C"
XThis exits \s-2JOVE\s0.  If any buffers need saving \s-2JOVE\s0 will print a warning
Xmessage and ask for confirmation.  If you leave without saving your
Xbuffers all your work will be lost.  If you made a mistake and really
Xdo want to exit then you can.  If you are in a recursive editing level
X.IQ exit-jove
Xwill return you from that.
X.dc "file-creation-mode" "(variable)"
XThis variable has an octal value.
XIt contains the mode (see
X.IQ chmod(1)
X) with which files should be created.  This mode gets modified by your
Xcurrent umask setting (see
X.IQ umask(1)
X).  The default value is usually
X.IQ 0666
Xor
X.IQ 0644.
X.dc "files-should-end-with-newline" "(variable)"
XThis variable indicates that all files should always have a newline
Xat the end.  This is often necessary for line printers and the like.
XWhen set, if \s-2JOVE\s0 is writing a file whose last character is not a
Xnewline, it will add one automatically.
X.dc "fill-comment" "Not Bound"
XThis command fills in your C comments to make them pretty and readable.
XThis filling is done according the variable
X.IQ comment-format.
X.DS L
X/*
X * the default format makes comments like this.
X */
X.DE
XThis can be changed by changing the format variable.  Other languages
Xmay be supported by changing the format variable appropriately.  The
Xformatter looks backwards from dot for an open comment symbol.  If
Xfound, all indentation is done relative the position of the first character
Xof the open symbol.  If there is a matching close symbol, the entire
Xcomment is formatted.  If not, the region between dot and the open symbol
Xis reformatted.
X.dc "fill-paragraph" "ESC J"
XThis rearranges words between lines so that all the lines in the current
Xparagraph extend as close to the right margin as possible, ensuring that
Xnone of the lines will be greater than the right margin.  The default value
Xfor
X.IQ right-margin
Xis 78, but can be changed with the
X.IQ set
Xand
X.IQ right-margin-here
Xcommands.  \s-2JOVE\s0 has a complicated algorithm
Xfor determining the beginning and end of the paragraph.  In the normal case
X\s-2JOVE\s0 will give all the lines the same indent as they currently have,
Xbut if you wish to force a new indent you can supply a numeric argument to
X.IQ fill-paragraph
X(e.g., by typing C-U ESC J)
Xand \s-2JOVE\s0 will indent each line to the column
Xspecified by the
X.IQ left-margin
Xvariable.  See also the
X.IQ left-margin
Xvariable and
X.IQ left-margin-here
Xcommand.
X.dc "fill-region" "Not Bound"
XThis is like
X.IQ fill-paragraph,
Xexcept it operates on a region instead of
Xjust a paragraph.
X.dc "filter-region" "Not Bound"
XThis sends the text in the region to a UNIX command, and replaces the
Xregion with the output from that command.  For example, if you are
Xlazy and don't like to take the time to write properly indented C
Xcode, you can put the region around your C file and
X.IQ filter-region
Xit
Xthrough
X.IQ cb,
Xthe UNIX C beautifier.  If you have a file that contains
Xa bunch of lines that need to be sorted you can do that from inside
X\s-2JOVE\s0 too, by filtering the region through the
X.IQ sort
XUNIX command.
XBefore output from the command replaces the region \s-2JOVE\s0 stores the old
Xtext in the kill ring, so if you are unhappy with the results you can
Xeasily get back the old text with "C-Y".
X.dc "find-file" "C-X C-F"
XThis visits a file into its own buffer and then selects that buffer.
XIf you've already visited this file in another buffer, that buffer is
Xselected.  If the file doesn't yet exist, \s-2JOVE\s0 will print "(New file)"
Xso that you know.
X.dc "find-tag" "C-X T"
XThis finds the file that contains the specified tag.  \s-2JOVE\s0 looks up
Xtags by default in the "tags" file in the current directory.  You can change
Xthe default tag name by setting the
X.IQ tag-file
Xvariable to another
Xname.  If you specify a numeric argument to this command, you will be
Xprompted for a tag file.  This is a good way to specify another tag file
Xwithout changing the default.  If the tag cannot be found the error is
Xreported and point stays where it is.
X.dc "find-tag-at-point" "Not Bound"
XThis finds the file that contains the tag that point is currently on.
XSee
X.IQ find-tag.
X.dc "first-non-blank" "ESC M"
XThis moves point back to the indent of the current line.
X.dc "forward-character" "C-F"
XThis moves forward over a single character.  If point is at the end of
Xthe line it moves to the beginning of the next one.
X.dc "forward-paragraph" "ESC ]"
XThis moves point forward to the end of the current or next paragraph.
XParagraphs are bounded by lines that begin with a Period or Tab, or by blank
Xlines; a change in indentation may also signal a break between paragraphs,
Xexcept that \s-2JOVE\s0 allows the first line of a paragraph to be indented
Xdifferently from the other lines.
X.dc "forward-s-expression" "ESC C-F"
XThis moves point forward over a s-expression.  If the first significant
Xcharacter after point is "(", this moves past the matching ")".  If the
Xcharacter begins an identifier, this moves just past it.  This is mode
Xdependent, so this will move over atoms in LISP mode and C identifiers in C
Xmode.  \s-2JOVE\s0 also matches "{".
X.dc "forward-sentence" "ESC E"
XThis moves point forward to the end of the current or next sentence.
X\s-2JOVE\s0 considers the end of a sentence to be the characters ".", "!" or
X"?" followed by a Return, or one or more spaces.
X.dc "forward-word" "ESC F"
XThis moves point forward to the end of the current or next word.
X.dc "fundamental-mode" "Not Bound"
XThis sets the major mode to Fundamental.  This affects what \s-2JOVE\s0
Xconsiders as characters that make up words.  For instance,
XSingle-quote is not part of a word in Fundamental mode, but is in Text
Xmode.
X.dc "goto-line" "ESC G"
XIf a numeric argument is supplied point moves to the beginning of that
Xline.  If no argument is supplied, point remains where it is.  This is
Xso you don't lose your place unintentionally, by accidentally hitting
Xthe "G" instead of "F".
X.dc "grind-s-expr" "Not Bound"
XWhen point is positioned on a "(", this re-indents that LISP expression.
X.dc "grow-window" "C-X ^"
XThis makes the current window one line bigger.  This only works when
Xthere is more than one window and provided there is room to change the
Xsize.
X.dc "paren-flash" ") } ]"
XThis handles the C mode curly brace indentation, the Lisp mode paren
Xindentation, and the Show Match mode paren/curly brace/square bracket
Xflashing.
X.dc "handle-tab" "Tab"
XThis handles indenting to the "right" place in C and Lisp mode, and
Xjust inserts itself in Text mode.
X.dc "i-search-forward" "Not Bound"
XIncremental search.  Like search-forward except that instead of prompting
Xfor a string and searching for that string all at once, it accepts the string
Xone character at a time.  After each character you type as part of the search
Xstring, it searches for the entire string so far.  When you like what it
Xfound, type the Return key to finish the search.  You can take back a
Xcharacter with Rubout and the search will back up to the position before
Xthat character was typed.  C-G aborts the search.
X.dc "i-search-reverse" "Not Bound"
XIncremental search.  Like search-reverse except that instead of prompting
Xfor a string and searching for that string all at once, it accepts the string
Xone character at a time.  After each character you type as part of the search
Xstring, it searches for the entire string so far.  When you like what it
Xfound, type the Return key to finish the search.  You can take back a
Xcharacter with Rubout and the search will back up to the position before
Xthat character was typed.  C-G aborts the search.
X.dc "insert-file" "C-X C-I"
XThis inserts a specified file into the current buffer at point.  Point
Xis positioned at the beginning of the inserted file.
X.dc "internal-tabstop" "(variable)"
XThe number of spaces \s-2JOVE\s0 should print when it displays a tab character.
XThe default value is 8.
X.dc "interrupt-character" "(variable)"
XThis is set to the character that interrupts JOVE (with a signal) no matter
Xwhat JOVE is doing.  It's main use is for interrupting non-interactive
Xprocesses, but it also has uses for debugging.  Unfortunately there is no
Xway to turn off the interrupt character.
X.dc "interrupt-process" "Not Bound"
XThis sends the interrupt character (usually C-C) to the interactive process
Xin the current buffer.  This is only for versions of \s-2JOVE\s0 that have the
Xinteractive processes feature.  This only works when you are inside a buffer
Xthat's attached to a process.
X.dc "shell" "Not Bound"
XThis starts up an interactive shell in a window.  \s-2JOVE\s0 uses
X"*shell*" as the name of the buffer in which the interacting takes
Xplace.  See the manual for information on how to use interactive
Xprocesses.
X.dc "i-shell-command" "Not Bound"
XThis is like
X.IQ shell-command
Xexcept it lets you continue with your
Xediting while the command is running.  This is really useful for long
Xrunning commands with sporadic output.  See the manual for information
Xon how to use interactive processes.
X.dc "kill-next-word" "ESC D"
XThis kills the text from point to the end of the current or next word.
X.dc "kill-previous-word" "ESC Rubout"
XThis kills the text from point to the beginning of the current or
Xprevious word.
X.dc "kill-process" "Not Bound"
XThis command prompts for a buffer name or buffer number (just as
Xselect-buffer does) and then sends the process in that buffer a
Xkill signal (9).
X.dc "kill-region" "C-W"
XThis deletes the text in the region and saves it on the kill ring.
XCommands that delete text but save it on the kill ring all have the
Xword "kill" in their names.  Type "C-Y" to yank back the most recent
Xkill.
X.dc "kill-s-expression" "ESC C-K"
XThis kills the text from point to the end of the current or next
Xs-expression.
X.dc "kill-some-buffers" "Not Bound"
XThis goes through all the existing buffers and asks whether or not to kill
Xthem.  If you decide to kill a buffer, and it turns out that the buffer is
Xmodified, \s-2JOVE\s0 will offer to save it first.  This is useful for when \s-2JOVE\s0
Xruns out of memory to store lines (this only happens on PDP-11's) and you
Xhave lots of buffers that you are no longer using.
X.dc "kill-to-beginning-of-sentence" "C-X Rubout"
XThis kills from point to the beginning of the current or previous
Xsentence.
X.dc "kill-to-end-of-line" "C-K"
XThis kills from point to the end of the current line.  When point is
Xat the end of the line the line separator is deleted and the next line
Xis joined with current one.  If a numeric argument is supplied that
Xmany lines are killed; if the argument is negative that many lines
X.IQ before
Xpoint are killed; if the argument is zero the text from point
Xto the beginning of the line is killed.
X.dc "kill-to-end-of-sentence" "ESC K"
XThis kills from point to the end of the current or next sentence.  If a
Xnegative numeric argument is supplied it kills from point to the
Xbeginning of the current or previous sentence.
X.dc "left-margin" "(variable)"
XThis is how far lines should be indented when auto-indent mode is on,
Xor when the
X.IQ newline-and-indent
Xcommand is run (usually by typing
XLineFeed).  It is also used by fill-paragraph and auto-fill mode.
XIf the value is zero (the default) then the left margin is determined
Xfrom the surrounding lines.
X.dc "left-margin-here" "Not Bound"
XThis sets the
X.IQ left-margin
Xvariable to the current position of
Xpoint.  This is an easy way to say, "Make the left margin begin here,"
Xwithout having to count the number of spaces over it actually is.
X.dc "lisp-mode" "Not Bound"
XThis turns on Lisp mode.  Lisp mode is one of four mutually exclusive major
Xmodes: Fundamental, Text, C, and Lisp.  In Lisp mode, the characters Tab
Xand ) are treated specially, similar to the way they are treated in C mode.
XAlso, Auto Indent mode is affected, and handled specially.
@//E*O*F doc/jove.4//
if test 33524 -ne "`wc -c <'doc/jove.4'`"; then
    echo shar: error transmitting "'doc/jove.4'" '(should have been 33524 characters)'
fi
fi # end of overwriting check
echo shar: "End of archive 11 (of 13)."
cp /dev/null ark11isdone
DONE=true
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13; do
    if test -f ark${I}isdone; then
        echo "You have run archive ${I}."
    else
        echo "You still need to run archive ${I}."
        DONE=false
    fi
done
case $DONE in
    true)
        echo "You have run all 13 archives."
        echo 'Now read the README and Makefile.'
        ;;
esac
##  End of shell archive.
exit 0